{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes:\n",
    " * increasing learning rate leads to overfitting, with significant drop in auc\n",
    " * this suggests we can use more data, or augmentation\n",
    " * the extra features show improvement: >1.5 higher auc\n",
    " * this model has weird structure, with lots of stuff plugged into the FC network..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/mnt/tess/astronet/checkpoints/extended_15_run_2/1/AstroCNNModel_extended_20201122_042827',\n",
       " '/mnt/tess/astronet/checkpoints/extended_15_run_2/2/AstroCNNModel_extended_20201122_045102',\n",
       " '/mnt/tess/astronet/checkpoints/extended_15_run_2/3/AstroCNNModel_extended_20201122_051334',\n",
       " '/mnt/tess/astronet/checkpoints/extended_15_run_2/4/AstroCNNModel_extended_20201122_053600',\n",
       " '/mnt/tess/astronet/checkpoints/extended_15_run_2/5/AstroCNNModel_extended_20201122_055828',\n",
       " '/mnt/tess/astronet/checkpoints/extended_15_run_2/6/AstroCNNModel_extended_20201122_062055',\n",
       " '/mnt/tess/astronet/checkpoints/extended_15_run_2/7/AstroCNNModel_extended_20201122_064326',\n",
       " '/mnt/tess/astronet/checkpoints/extended_15_run_2/8/AstroCNNModel_extended_20201122_070554',\n",
       " '/mnt/tess/astronet/checkpoints/extended_15_run_2/9/AstroCNNModel_extended_20201122_072831',\n",
       " '/mnt/tess/astronet/checkpoints/extended_15_run_2/10/AstroCNNModel_extended_20201122_075104']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "chkpt_root = '/mnt/tess/astronet/checkpoints/extended_15_run_2'\n",
    "data_files = '/mnt/tess/astronet/tfrecords-15-val/*'\n",
    "tces_file = '/mnt/tess/astronet/tces-v3-val.csv'\n",
    "\n",
    "nruns = 10\n",
    "\n",
    "def load_ensemble(chkpt_root, nruns):\n",
    "    checkpts = []\n",
    "    for i in range(nruns):\n",
    "        parent = os.path.join(chkpt_root, str(i + 1))\n",
    "        if not os.path.exists(parent):\n",
    "            break\n",
    "        all_dirs = os.listdir(parent)\n",
    "        if not all_dirs:\n",
    "            break\n",
    "        d, = all_dirs\n",
    "        checkpts.append(os.path.join(parent, d))\n",
    "    return checkpts\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running model 1\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "1335 records\n",
      "Running model 2\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "1335 records\n",
      "Running model 3\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "1335 records\n",
      "Running model 4\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "1335 records\n",
      "Running model 5\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "1335 records\n",
      "Running model 6\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "1335 records\n",
      "Running model 7\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "1335 records\n",
      "Running model 8\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "1335 records\n",
      "Running model 9\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "1335 records\n",
      "Running model 10\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "1335 records\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "import os\n",
    "from astronet import predict\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "def run_predictions(path):\n",
    "    predict.FLAGS = predict.parser.parse_args([\n",
    "      '--model_dir', path,\n",
    "      '--data_files', data_files,\n",
    "      '--output_file', '',\n",
    "    ])\n",
    "\n",
    "    return predict.predict()\n",
    "\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "ensemble_preds = []\n",
    "config = None\n",
    "for i, path in enumerate(paths):\n",
    "    print(f'Running model {i + 1}')\n",
    "    preds, config = run_predictions(path)\n",
    "    ensemble_preds.append(preds.set_index('tic_id'))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "agg_preds = {}\n",
    "\n",
    "for preds in ensemble_preds:\n",
    "    for tic_id in preds.index:\n",
    "        if tic_id not in agg_preds:\n",
    "            agg_preds[tic_id] = []\n",
    "\n",
    "        row = preds[preds.index == tic_id]\n",
    "        pred_v = row.values[0]\n",
    "        if len(row.values) > 1:\n",
    "            print(f'Warning: duplicate predictions for {tic_id}')\n",
    "        if pred_v[0] >= config.hparams.prediction_threshold:\n",
    "            agg_preds[tic_id].append('disp_E')\n",
    "        else:\n",
    "            agg_preds[tic_id].append(preds.columns[np.argmax(pred_v)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['disp_E', 'disp_N', 'disp_J', 'disp_S', 'disp_B']\n",
    "\n",
    "final_preds = []\n",
    "for tic_id in list(agg_preds.keys()):\n",
    "    counts = {l: 0 for l in labels}\n",
    "    for e in agg_preds[tic_id]:\n",
    "        counts[e] += 1\n",
    "    maxcount = max(counts.values())\n",
    "    counts.update({\n",
    "        'tic_id': tic_id,\n",
    "        'maxcount': maxcount,\n",
    "    })\n",
    "    final_preds.append(counts)\n",
    "    \n",
    "final_preds = pd.DataFrame(final_preds).set_index('tic_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "tce_table = pd.read_csv(tces_file, header=0).set_index('tic_id')\n",
    "tce_labels = tce_table[labels]\n",
    "\n",
    "pl = final_preds.join(tce_labels, on='tic_id', how='left', lsuffix='_p')\n",
    "\n",
    "pl.head()\n",
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 0.937888198757764\n",
      "Precision: 0.755\n"
     ]
    }
   ],
   "source": [
    "ppos = (pl['disp_E_p'] > 0)\n",
    "pos = (pl['disp_E'] > 0)\n",
    "\n",
    "pneg = (pl['disp_E_p'] == 0)\n",
    "neg = (pl['disp_E'] == 0)\n",
    "\n",
    "print('Recall:', len(pl[ppos & pos]) / len(pl[pos]))\n",
    "print('Precision:', len(pl[ppos & pos]) / len(pl[ppos]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "118412801\n",
      "119344901\n",
      "141753278\n",
      "158159741\n",
      "276978548\n",
      "349412074\n",
      "365242787\n",
      "384065528\n",
      "404220255\n",
      "104485403\n"
     ]
    }
   ],
   "source": [
    "for i in pl[pos & pneg][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_E</th>\n",
       "      <th>disp_N</th>\n",
       "      <th>disp_J</th>\n",
       "      <th>disp_S</th>\n",
       "      <th>disp_B</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_E, disp_N, disp_J, disp_S, disp_B]\n",
       "Index: []"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare(ensemble_preds, filter):\n",
    "    result = ensemble_preds[0][filter]\n",
    "    for preds in ensemble_preds[1:]:\n",
    "        result = result.append(preds[filter])\n",
    "    return result\n",
    "\n",
    "compare(ensemble_preds, preds.index == 116252237)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_E_p</th>\n",
       "      <th>disp_N_p</th>\n",
       "      <th>disp_J_p</th>\n",
       "      <th>disp_S_p</th>\n",
       "      <th>disp_B_p</th>\n",
       "      <th>maxcount</th>\n",
       "      <th>disp_E</th>\n",
       "      <th>disp_N</th>\n",
       "      <th>disp_J</th>\n",
       "      <th>disp_S</th>\n",
       "      <th>disp_B</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_E_p, disp_N_p, disp_J_p, disp_S_p, disp_B_p, maxcount, disp_E, disp_N, disp_J, disp_S, disp_B]\n",
       "Index: []"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl[pl.index == 114053589]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PR curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 1335)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tics = set(ensemble_preds[0].index.values)\n",
    "\n",
    "tic_index = {v: i for i, v in enumerate(tics)}\n",
    "\n",
    "pred_es = np.zeros([len(ensemble_preds), len(tic_index)])\n",
    "for i, preds in enumerate(ensemble_preds):\n",
    "    for row in preds.iterrows():\n",
    "        tic, pred_e = row[0], row[1][0]\n",
    "        pred_es[i][tic_index[tic]] = pred_e\n",
    "        \n",
    "pred_es.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "lbl_es = np.zeros([len(tic_index)], dtype=np.bool)\n",
    "for row in tce_labels.iterrows():\n",
    "    tic, lbl_e = row[0], row[1]['disp_E']\n",
    "    if tic in tic_index:\n",
    "        lbl_es[tic_index[tic]] = (lbl_e > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cond_pos = float(np.sum(lbl_es))\n",
    "\n",
    "def pr_at_th(th):\n",
    "    pred_pos = np.any(pred_es >= th, axis=0)\n",
    "    true_pos = pred_pos & lbl_es\n",
    "    num_pred_pos = float(np.sum(pred_pos))\n",
    "    num_true_pos = float(np.sum(true_pos))\n",
    "    if num_pred_pos == 0:\n",
    "        return 1.0, 0.0\n",
    "    return float(num_true_pos) / float(num_pred_pos), float(num_true_pos) / float(num_cond_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC: 0.9535733673145018, max R: 1.0, max P: 1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x740 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "ps, rs = ([], [])\n",
    "th = np.max(pred_es)\n",
    "while th >= 0.0:\n",
    "    p, r = pr_at_th(th)\n",
    "    if p > 0:\n",
    "        ps.append(p)\n",
    "        rs.append(r)\n",
    "    else:\n",
    "        ps.append(1.0)\n",
    "        rs.append(0.0)\n",
    "    th -= 0.0005\n",
    "    \n",
    "from sklearn import metrics\n",
    "\n",
    "print(f'AUC: {metrics.auc(rs, ps)}, max R: {max(rs)}, max P: {max(ps)}')\n",
    "    \n",
    "fig, ax = plt.subplots(figsize=(6, 3.7), dpi=200)\n",
    "\n",
    "ax.spines['top'].set_color('#808080')\n",
    "ax.spines['right'].set_color('#808080')\n",
    "ax.spines['left'].set_color('#808080')\n",
    "ax.spines['bottom'].set_color('#808080')\n",
    "ax.tick_params(direction='in', color='#808080')\n",
    "\n",
    "plt.grid(color='#c0c0c0', linestyle='--', linewidth=0.5)\n",
    "\n",
    "plt.ylabel('Precision', fontweight='bold')\n",
    "plt.xlabel('Recall', fontweight='bold')\n",
    "\n",
    "plt.xlim((0.0, 1.0))\n",
    "plt.ylim((0.0, 1.0))\n",
    "\n",
    "_ = plt.plot(rs, ps)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
